LLD Interview Cheat Sheet

📋 The 6-Step Template (45-60 min Interview)

Step	Time	Focus	Key Actions
1️⃣ Requirements	8-10 min	🔥 CRITICAL	Ask questions, clarify scope
2️⃣ Entities & Relations	8-10 min	🔥 CRITICAL	Find nouns, define relationships
3️⃣ Class Design	10-12 min	🔥 CRITICAL	Attributes + responsibilities
4️⃣ Interface Definition	6-8 min	🚨 HIGH	Method signatures + contracts
5️⃣ Implementation	12-15 min	🚨 HIGH	Skeleton code, OOP principles
6️⃣ Edge Cases	5-8 min	⚡ MEDIUM	Failures + extensions

---

1️⃣ Requirements Clarification (8-10 min)

✅ Questions to Ask:

🔍 FUNCTIONAL:
- What are the core features?
- Who are the users?
- What operations are needed?
- Any specific business rules?

🔍 NON-FUNCTIONAL:
- How many users/requests?
- Performance requirements?
- Consistency vs Availability?
- Storage constraints?

🔍 SCOPE:
- What's included/excluded?
- Mobile app needed?
- Payment integration?
- Real-time updates?

🎯 Output: Clear requirements list

---

2️⃣ Core Entities & Relationships (8-10 min)

✅ Find Nouns (Classes):

Example: "Park vehicle in parking lot, generate ticket"
→ Vehicle, ParkingLot, ParkingSlot, Ticket

✅ Define Relationships:

IS-A (Inheritance):     Car IS-A Vehicle
HAS-A (Composition):    ParkingLot HAS-A List<Slot>
USES-A (Association):   Ticket USES Vehicle + Slot

🚨 Abstract vs Interface Decision:

• Abstract: Shared attributes + some behavior (Vehicle → Car, Bike)
• Interface: Contract/capability (Payable, Notifiable)

---

3️⃣ Class Design (10-12 min) - MOST CRITICAL

✅ For Each Class Define:

Class Name
├── Attributes (private/protected)
├── Responsibilities (what it does)
├── Key methods (public interface)
└── Relationships to other classes

🎯 OOP Principles Checklist:

• ✅ Encapsulation: Private fields, public getters/setters
• ✅ Inheritance: Proper IS-A relationships
• ✅ Polymorphism: Abstract methods, overriding
• ✅ Abstraction: Hide complex implementation

🚨 Design Principles (SOLID):

• Single Responsibility: One class, one job
• Open/Closed: Open for extension, closed for modification
• Liskov Substitution: Subclasses should be replaceable
• Interface Segregation: Small, focused interfaces
• Dependency Inversion: Depend on abstractions

---

4️⃣ Interface Definition (6-8 min)

✅ Define Method Contracts:

public interface ParkingSystem {
    ParkingTicket parkVehicle(Vehicle vehicle) throws NoSlotException;
    boolean unparkVehicle(String ticketId) throws InvalidTicketException;
    int getAvailableSlots(VehicleType type);
    double calculateFee(String ticketId);
}

🎯 Method Design Tips:

• Clear method names (no ambiguity)
• Proper return types
• Exception handling strategy
• Parameter validation

---

5️⃣ Implementation (12-15 min)

✅ Code Structure Priority:

1. Core classes first (2-3 main classes)
2. Key methods only (not all getters/setters)
3. Main controller/manager class
4. Basic logic (don't perfect syntax)

🎯 What to Show in Code:

// ✅ Show inheritance
abstract class Vehicle {
    protected String id;
    public abstract VehicleType getType();
}

// ✅ Show composition
class ParkingLot {
    private List<ParkingSlot> slots;
    private Map<String, Ticket> tickets;
}

// ✅ Show polymorphism
public ParkingTicket parkVehicle(Vehicle vehicle) {
    // Different logic based on vehicle.getType()
}

🚨 Quick Implementation Tips:

• Use enums for constants (VehicleType, SlotType)
• Collections for storage (List, Map, Set)
• Exception handling (custom exceptions)
• Basic validation logic

---

6️⃣ Edge Cases & Extensions (5-8 min)

✅ Common Edge Cases:

🚨 FAILURE SCENARIOS:
- No available slots
- Invalid ticket/ID
- Duplicate operations
- Concurrent access issues
- Invalid input data

💡 VALIDATIONS:
- Null checks
- Range validations
- State validations
- Business rule violations

✅ Design Patterns (Mention if Time):

🎯 COMMON PATTERNS:
- Factory: Creating vehicles/slots
- Singleton: ParkingLot instance
- Strategy: Different pricing strategies
- Observer: Notify on slot availability
- Command: Parking operations
- State: Slot states (occupied/free)

✅ Scaling Considerations:

📈 SCALABILITY:
- Database persistence
- Caching (Redis)
- Load balancing
- Microservices
- Event-driven architecture
- Thread safety (synchronized, locks)

---

⏰ Time Management Checkpoints

Time	Checkpoint	If Behind
15 min	Requirements + Entities done	Skip some clarifying questions
25 min	Class design complete	Combine class design + interfaces
40 min	Core implementation done	Show skeleton only
50 min	Edge cases discussed	Quick summary of extensions

---

🎯 Interview Success Formula

📢 Communication Tips:

🗣️ SPEAK YOUR THOUGHT PROCESS:
- "Let me clarify the requirements first..."
- "I see three main entities here..."
- "I'm running short on time, so I'll focus on..."
- "This is how I'd handle this edge case..."

🎯 Prioritization Strategy:

HIGH IMPACT:
✅ Complete requirements understanding
✅ Clean OOP design
✅ Working core implementation
✅ Clear communication

MEDIUM IMPACT:
⚡ Interface contracts
⚡ Edge case handling
⚡ Design patterns mention

LOW IMPACT:
🔹 Perfect syntax
🔹 Complete implementation
🔹 Advanced scalability discussion

---

🚨 Common Mistakes to Avoid

❌ DON'T	✅ DO
Spend 20+ min on requirements	8-10 min max, then move
Perfect code syntax	Focus on structure & logic
Implement every method	Show key methods, mention others
Over-engineer with patterns	Simple design first
Silent coding	Explain your thinking
Jump to code immediately	Design first, code later

---

📚 Common LLD Problems Prep

🎯 Must Practice:

1. Parking Lot System ⭐⭐⭐
2. Chess Game ⭐⭐⭐
3. ATM System ⭐⭐
4. Elevator System ⭐⭐
5. Hotel Booking System ⭐⭐
6. Library Management ⭐
7. Restaurant Management ⭐
8. Online Shopping Cart ⭐

🔄 Pattern Recognition:

• Booking Systems: Hotel, Flight, Movie → Similar entities (Room, Seat, User, Booking)
• Game Systems: Chess, Tic-tac-toe, Snake → Board, Player, Game state
• Management Systems: Library, Hospital, School → Person, Resource, Transaction

---

🏆 Final Checklist Before Interview

□ Practice 2-3 LLD problems using this template
□ Review OOP principles & SOLID
□ Practice explaining design decisions
□ Time yourself (45-60 min practice)
□ Prepare clarifying questions for any LLD
□ Review common design patterns
□ Practice whiteboard/drawing skills
□ Prepare for follow-up scaling questions

---

💡 Last Minute Tips

🎯 Show Problem-Solving Approach:

• Think out loud
• Ask clarifying questions
• Start simple, add complexity
• Trade-offs discussion
• Clean, readable code structure

🗣️ Sample Phrases to Use:

• "Let me clarify the requirements..."
• "I see this as an inheritance vs composition decision..."
• "For scalability, we could consider..."
• "The trade-off here is..."
• "Given time constraints, I'll focus on..."

🚀 Confidence Boosters:

• You know OOP principles ✅
• You understand design patterns ✅
• You can write clean code ✅
• You can explain your thinking ✅
• You've practiced this template ✅

Remember: Perfect solution < Complete working solution with good design! 🎯

---

🍀 Good luck with your interview! Stay calm, follow the template, and show your problem-solving skills.